document.addEventListener('DOMContentLoaded', () => {
    // 获取DOM元素
    const gridContainer = document.getElementById('grid-container');
    const currentNumberElement = document.getElementById('current-number');
    const timerElement = document.getElementById('timer');
    const startBtn = document.getElementById('start-btn');
    const currentLevelDisplay = document.getElementById('current-level-display');
    const levelDetail = document.getElementById('level-detail');
    const timeLimitBarContainer = document.getElementById('time-limit-bar-container');
    const timeLimitBar = document.getElementById('time-limit-bar');
    const levelSelect = document.getElementById('level-select');
    const viewLevelDetailsBtn = document.getElementById('view-level-details');
    const levelDetailOverlay = document.getElementById('level-detail-overlay');
    const closeLevelDetailBtn = document.getElementById('close-level-detail');

    // 确保时间限制条在初始状态下隐藏
    timeLimitBar.style.width = '100%';

    // 音效系统
    const correctAudio = new Audio('https://assets.mixkit.co/active_storage/sfx/1114/1114-preview.mp3'); // 更清脆的选对音效
    const wrongAudio = new Audio('https://assets.mixkit.co/active_storage/sfx/2872/2872-preview.mp3'); // 选错音效
    const successAudio = new Audio('https://assets.mixkit.co/active_storage/sfx/2013/2013-preview.mp3'); // 完成关卡音效
    const failureAudio = new Audio('https://assets.mixkit.co/active_storage/sfx/2955/2955-preview.mp3'); // 失败音效

    // 预加载音频
    [correctAudio, wrongAudio, successAudio, failureAudio].forEach(audio => {
        audio.load(); // 预加载音频
        audio.volume = 0.5; // 设置音量为50%
    });

    // 播放音效的函数
    function playSound(sound) {
        if (!soundEnabled) return;

        // 克隆音频对象以允许多次重叠播放
        const audioClone = sound.cloneNode();
        audioClone.volume = sound.volume;
        audioClone.play().catch(e => console.log('无法播放音效:', e));

        // 播放完后移除克隆的音频对象
        audioClone.onended = function () {
            audioClone.remove();
        };
    }

    // 蒙层元素
    const modalOverlay = document.getElementById('modal-overlay');
    const modalTitle = document.getElementById('modal-title');
    const modalTime = document.getElementById('modal-time');
    const modalStars = document.getElementById('modal-stars');
    const modalLevelMessage = document.getElementById('modal-level-message');
    const modalLevelStatus = document.getElementById('modal-level-status');
    const modalNextBtn = document.getElementById('modal-next-btn');
    const modalRestartBtn = document.getElementById('modal-restart-btn');

    // 游戏变量
    let currentNumber = 1;
    let maxNumber = 9;
    let gridSize = 3;
    let timer;
    let seconds = 0;
    let gameActive = false;
    let currentLevel = 1;
    let timeLimitTimer;
    let timeLimit = 0;
    let moveTimer;
    let wrongClicks = 0; // 点击错误的次数
    let maxWrongClicks = 3; // 允许的最大错误次数，默认为3

    // 调试模式变量
    let debugMode = false;
    let debugSequence = []; // 用于存储用户输入的按键序列
    const debugCode = ['d', 'e', 'b', 'u', 'g']; // 激活调试模式的按键序列
    let debugPanel = null; // 调试面板元素

    // 本地存储键
    const STORAGE_KEY = 'schulteGame';

    // 关卡定义
    const levels = [
        {
            id: 1,
            name: '初学者',
            gridSize: 3,
            description: '3×3 格子，适合初学者入门。',
            timeLimit: 0,
            colorDistraction: false,
            moving: false,
            starTimes: [15, 10, 5], // 分别是1星、2星、3星的时间阈值（秒）
        },
        {
            id: 2,
            name: '简单',
            gridSize: 4,
            description: '4×4 格子，稍微增加难度。',
            timeLimit: 0,
            colorDistraction: false,
            moving: false,
            starTimes: [30, 20, 12],
        },
        {
            id: 3,
            name: '常规',
            gridSize: 5,
            description: '5×5 格子，标准舒尔特方格。',
            timeLimit: 0,
            colorDistraction: false,
            moving: false,
            starTimes: [45, 30, 20],
        },
        {
            id: 4,
            name: '计时挑战',
            gridSize: 5,
            description: '5×5 格子，增加了时间限制：60秒内完成。',
            timeLimit: 60,
            colorDistraction: false,
            moving: false,
            starTimes: [45, 30, 20],
        },
        {
            id: 5,
            name: '进阶',
            gridSize: 6,
            description: '6×6 格子，更多数字需要识别。',
            timeLimit: 0,
            colorDistraction: false,
            moving: false,
            starTimes: [60, 45, 30],
        },
        {
            id: 6,
            name: '颜色干扰',
            gridSize: 5,
            description: '5×5 格子，增加颜色干扰，提高注意力挑战。',
            timeLimit: 0,
            colorDistraction: true,
            moving: false,
            starTimes: [50, 35, 25],
        },
        {
            id: 7,
            name: '高级',
            gridSize: 7,
            description: '7×7 格子，共49个数字需要按顺序找出。',
            timeLimit: 0,
            colorDistraction: false,
            moving: false,
            starTimes: [90, 70, 50],
        },
        {
            id: 8,
            name: '移动挑战',
            gridSize: 5,
            description: '5×5 格子，数字会轻微移动，增加识别难度。',
            timeLimit: 0,
            colorDistraction: false,
            moving: true,
            starTimes: [55, 40, 30],
        },
        {
            id: 9,
            name: '专家',
            gridSize: 6,
            description: '6×6 格子，数字会移动且有颜色干扰，90秒时间限制。',
            timeLimit: 90,
            colorDistraction: true,
            moving: true,
            starTimes: [70, 55, 40],
        },
        {
            id: 10,
            name: '大师级',
            gridSize: 7,
            description: '7×7 格子，终极挑战：数字移动，颜色干扰，120秒时间限制。',
            timeLimit: 120,
            colorDistraction: true,
            moving: true,
            starTimes: [100, 80, 60],
        },
    ];

    // 加载游戏数据
    function loadGameData() {
        const savedData = localStorage.getItem(STORAGE_KEY);
        if (savedData) {
            return JSON.parse(savedData);
        } else {
            // 初始化数据结构
            const initialData = {
                levels: {},
            };

            // 设置每个关卡的初始数据
            levels.forEach(level => {
                initialData.levels[level.id] = {
                    bestTime: null,
                    stars: 0,
                    unlocked: level.id === 1, // 只有第一关默认解锁
                };
            });

            // 保存初始数据
            saveGameData(initialData);
            return initialData;
        }
    }

    // 保存游戏数据
    function saveGameData(data) {
        localStorage.setItem(STORAGE_KEY, JSON.stringify(data));
    }

    // 根据完成时间计算星级
    function calculateStars(levelId, completionTime) {
        const level = levels.find(l => l.id === levelId);

        if (!level) return 0;

        const starTimes = level.starTimes;

        if (completionTime <= starTimes[2]) {
            return 3; // 3星
        } else if (completionTime <= starTimes[1]) {
            return 2; // 2星
        } else if (completionTime <= starTimes[0]) {
            return 1; // 1星
        } else {
            return 1; // 至少1星（完成即可）
        }
    }

    // 更新关卡选择中的星级显示
    function updateLevelSelectWithStars() {
        const gameData = loadGameData();

        Array.from(levelSelect.options).forEach(option => {
            const levelId = parseInt(option.value);
            const levelData = gameData.levels[levelId];

            if (!levelData) return;

            let prefix = '';
            if (levelData.unlocked) {
                // 添加星级显示
                for (let i = 0; i < 3; i++) {
                    prefix += i < levelData.stars ? '★' : '☆';
                }
                prefix += ' ';
            } else {
                prefix = '🔒 '; // 锁定标志
            }

            // 更新选项文本
            const originalText = option.textContent.replace(/^([★☆🔒 ]+)?\s*/, '');
            option.textContent = prefix + originalText;

            // 设置是否禁用
            option.disabled = !levelData.unlocked;
        });
    }

    // 更新关卡描述并设置时间限制条状态
    function updateLevelDescription(levelId) {
        const level = levels.find(l => l.id === levelId);
        const gameData = loadGameData();
        const levelData = gameData.levels[levelId];

        if (level && levelData) {
            // 根据关卡特性设置不同的详情按钮样式
            let tooltipText = '查看关卡详情';
            if (level.timeLimit > 0) {
                tooltipText = '查看时间限制详情';
            } else if (level.colorDistraction && level.moving) {
                tooltipText = '查看特殊挑战详情';
            } else if (level.colorDistraction) {
                tooltipText = '查看颜色干扰详情';
            } else if (level.moving) {
                tooltipText = '查看移动挑战详情';
            }
            viewLevelDetailsBtn.title = tooltipText;

            // 根据关卡难度设置按钮样式
            if (levelId <= 3) {
                viewLevelDetailsBtn.style.backgroundColor = '#4CAF50'; // 绿色 - 简单
            } else if (levelId <= 6) {
                viewLevelDetailsBtn.style.backgroundColor = '#FF9800'; // 橙色 - 中等
            } else {
                viewLevelDetailsBtn.style.backgroundColor = '#F44336'; // 红色 - 困难
            }

            // 优化格式，使其在所有设备上都有良好的可读性
            let descText = `<h3>关卡 ${level.id}: ${level.name}</h3>`;
            descText += `<p>${level.description}</p>`;

            // 添加最佳时间显示
            if (levelData.bestTime !== null) {
                descText += `<div class="record-info">最佳时间: ${levelData.bestTime}秒 (`;
                for (let i = 0; i < 3; i++) {
                    descText += i < levelData.stars ? '★' : '☆';
                }
                descText += ')</div>';
            }

            // 添加星级要求说明
            descText += '<div class="star-req">星级要求:</div>';
            descText += `<p>● 1星: ${level.starTimes[0]}秒 或更快</p>`;
            descText += `<p>● 2星: ${level.starTimes[1]}秒 或更快</p>`;
            descText += `<p>● 3星: ${level.starTimes[2]}秒 或更快</p>`;

            // 添加通关要求
            descText +=
                '<p><br><strong>注意:</strong> 需要获得 <span style="color:#FFD700">★★★</span> 才能通关并解锁下一关！</p>';

            // 添加错误点击限制说明
            let maxErrors;
            if (levelId <= 3) {
                maxErrors = 3;
            } else if (levelId <= 7) {
                maxErrors = 2;
            } else {
                maxErrors = 1;
            }
            descText += `<p><br><strong style="color:#f44336">警告:</strong> 点错 ${maxErrors} 次将导致任务失败！</p>`;

            // 如果有时间限制，添加时间限制信息
            if (level.timeLimit > 0) {
                descText += `<p><br><strong style="color:#FF9800">时间限制:</strong> 你有 ${level.timeLimit} 秒的时间完成挑战！</p>`;
            }

            // 添加特殊挑战说明
            if (level.colorDistraction || level.moving) {
                descText += '<div class="star-req">特殊挑战:</div>';
                if (level.colorDistraction) {
                    descText += '<p>● <strong>颜色干扰:</strong> 数字将会有颜色干扰，增加识别难度。</p>';
                }
                if (level.moving) {
                    descText += '<p>● <strong>移动挑战:</strong> 数字将会轻微移动，增加跟踪难度。</p>';
                }
            }

            // 更新详细关卡描述（蒙层中的内容）
            levelDetail.innerHTML = descText;
            currentLevelDisplay.textContent = level.id;
        }
    }

    // 显示关卡详情蒙层
    viewLevelDetailsBtn.addEventListener('click', () => {
        levelDetailOverlay.classList.add('active');
    });

    // 关闭关卡详情蒙层
    closeLevelDetailBtn.addEventListener('click', () => {
        levelDetailOverlay.classList.remove('active');
    });

    // 点击蒙层背景也可以关闭关卡详情
    levelDetailOverlay.addEventListener('click', function (e) {
        if (e.target === levelDetailOverlay) {
            levelDetailOverlay.classList.remove('active');
        }
    });

    // 初始化关卡数据和描述
    function initializeLevels() {
        const gameData = loadGameData();
        updateLevelSelectWithStars();
        updateLevelDescription(1); // 默认选择第一关

        // 设置第一个未锁定关卡为默认选择
        for (let i = 1; i <= levels.length; i++) {
            if (gameData.levels[i] && gameData.levels[i].unlocked) {
                levelSelect.value = i;
                updateLevelDescription(i);
                break;
            }
        }
    }

    // 初始化游戏
    function initGame() {
        // 清除之前的计时器
        clearAllTimers();

        // 隐藏关卡详情蒙层（如果正在显示）
        levelDetailOverlay.classList.remove('active');

        // 获取选定的关卡
        currentLevel = parseInt(levelSelect.value);
        const level = levels.find(l => l.id === currentLevel);
        const gameData = loadGameData();

        if (!level || !gameData.levels[currentLevel].unlocked) return;

        // 重置游戏状态
        currentNumber = 1;
        seconds = 0;
        gridSize = level.gridSize;
        maxNumber = gridSize * gridSize;
        timeLimit = level.timeLimit;
        wrongClicks = 0; // 重置错误点击次数

        // 根据关卡难度设置允许的最大错误次数
        if (currentLevel <= 3) {
            maxWrongClicks = 3; // 初级关卡允许3次错误
        } else if (currentLevel <= 7) {
            maxWrongClicks = 2; // 中级关卡允许2次错误
        } else {
            maxWrongClicks = 1; // 高级关卡只允许1次错误
        }

        // 更新UI
        timerElement.textContent = '0';
        currentNumberElement.textContent = '1';
        gridContainer.innerHTML = '';
        gridContainer.classList.remove('hidden');
        currentLevelDisplay.textContent = currentLevel;

        // 添加游戏激活类以显示网格
        document.querySelector('.container').classList.add('game-active');
        document.querySelector('.game-area').classList.add('game-active');

        // 更新网格列数
        gridContainer.style.gridTemplateColumns = `repeat(${gridSize}, 1fr)`;

        // 生成1到maxNumber的数组
        const numbers = Array.from({ length: maxNumber }, (_, i) => i + 1);

        // 打乱数组
        shuffleArray(numbers);

        // 创建网格单元格
        numbers.forEach(number => {
            const gridItem = document.createElement('div');
            gridItem.classList.add('grid-item');

            // 应用关卡特殊效果
            if (level.colorDistraction) {
                gridItem.classList.add('color-distraction');
            }

            if (level.moving) {
                gridItem.classList.add('moving');
                // 使每个元素的动画延迟不同，产生错落感
                gridItem.style.animationDelay = `${(Math.random() * 2).toFixed(1)}s`;
            }

            gridItem.textContent = number;
            gridItem.dataset.number = number;
            gridItem.addEventListener('click', () => handleItemClick(gridItem));
            gridContainer.appendChild(gridItem);
        });

        // 启动计时器
        timer = setInterval(() => {
            seconds++;
            timerElement.textContent = seconds;
        }, 1000);

        // 如果有时间限制，显示并启动时间条
        if (timeLimit > 0) {
            // 确保时间条容器可见 - 强制显示
            timeLimitBarContainer.style.display = 'block';
            timeLimitBar.style.width = '100%';
            timeLimitBar.classList.remove('time-warning', 'time-danger');

            // 确保计时器和时间限制条在初始化时可见
            timerElement.style.display = 'flex';

            let remainingTime = timeLimit;

            timeLimitTimer = setInterval(() => {
                remainingTime--;

                // 更新时间条
                const percentage = (remainingTime / timeLimit) * 100;
                timeLimitBar.style.width = `${percentage}%`;

                // 增加视觉警告
                if (percentage <= 50 && percentage > 25) {
                    timeLimitBar.classList.add('time-warning');
                    timeLimitBar.classList.remove('time-danger');
                } else if (percentage <= 25) {
                    timeLimitBar.classList.add('time-danger');
                    timeLimitBar.classList.remove('time-warning');
                }

                // 时间用完
                if (remainingTime <= 0) {
                    clearAllTimers();
                    gameActive = false;

                    // 移除游戏激活类
                    document.querySelector('.container').classList.remove('game-active');

                    // 设置蒙层内容
                    modalTitle.textContent = '时间到！再试一次吧';
                    modalTime.textContent = seconds;
                    modalLevelMessage.classList.add('hidden');
                    modalNextBtn.style.display = 'none';

                    // 显示蒙层
                    modalOverlay.classList.add('active');

                    // 不隐藏时间条容器，只是重置它
                    timeLimitBar.style.width = '0%';
                }
            }, 1000);
        } else {
            // 如果没有时间限制，隐藏时间条但确保计时器显示
            timeLimitBarContainer.style.display = 'none';
            timerElement.style.display = 'flex';
        }

        gameActive = true;
    }

    // 清除所有计时器
    function clearAllTimers() {
        clearInterval(timer);
        clearInterval(timeLimitTimer);
        clearInterval(moveTimer);
    }

    // 打乱数组的函数（Fisher-Yates算法）
    function shuffleArray(array) {
        for (let i = array.length - 1; i > 0; i--) {
            const j = Math.floor(Math.random() * (i + 1));
            [array[i], array[j]] = [array[j], array[i]];
        }
        return array;
    }

    // 处理单元格点击
    function handleItemClick(gridItem) {
        if (!gameActive) return;

        const clickedNumber = parseInt(gridItem.dataset.number);

        if (clickedNumber === currentNumber) {
            // 点击正确 - 播放正确音效
            playSound(correctAudio);

            currentNumber++;

            if (currentNumber <= maxNumber) {
                currentNumberElement.textContent = currentNumber;
            } else {
                // 游戏完成
                gameComplete(true);
            }
        } else {
            // 点击错误 - 播放错误音效
            playSound(wrongAudio);

            wrongClicks++;
            gridItem.classList.add('wrong');

            // 如果错误次数达到上限，游戏失败
            if (wrongClicks >= maxWrongClicks) {
                // 在点击错误时添加震动效果
                gridContainer.classList.add('shake-effect');

                setTimeout(() => {
                    gridItem.classList.remove('wrong');
                    gridContainer.classList.remove('shake-effect');
                    gameComplete(false, true); // 传递第二个参数表示是因为错误次数过多导致的失败
                }, 800);
            } else {
                setTimeout(() => {
                    gridItem.classList.remove('wrong');
                }, 500);
            }
        }
    }

    // 游戏完成处理
    function gameComplete(success, tooManyErrors = false) {
        gameActive = false;
        clearAllTimers();

        // 移除游戏激活类
        document.querySelector('.container').classList.remove('game-active');
        document.querySelector('.game-area').classList.remove('game-active');

        // 隐藏关卡详情蒙层（如果正在显示）
        levelDetailOverlay.classList.remove('active');

        // 播放成功或失败的音效
        if (success) {
            playSound(successAudio);
        } else {
            playSound(failureAudio);
        }

        // 重置所有UI元素，避免信息混淆
        modalStars.innerHTML = '';
        modalLevelMessage.innerHTML = '';
        modalNextBtn.style.display = 'none';

        if (success) {
            // 成功完成游戏的处理

            // 计算星级并更新游戏数据
            const stars = calculateStars(currentLevel, seconds);
            const gameData = loadGameData();

            // 更新当前关卡的最佳时间和星级
            if (gameData.levels[currentLevel].bestTime === null || seconds < gameData.levels[currentLevel].bestTime) {
                gameData.levels[currentLevel].bestTime = seconds;
            }

            // 更新星级（取最高的）
            gameData.levels[currentLevel].stars = Math.max(gameData.levels[currentLevel].stars, stars);

            // 判断是否解锁下一关
            if (currentLevel < levels.length && stars >= 3) {
                // 需要至少3星才能解锁下一关
                gameData.levels[currentLevel + 1].unlocked = true;
            }

            // 保存游戏数据
            saveGameData(gameData);

            // 更新UI
            updateLevelSelectWithStars();

            // 设置成功蒙层内容
            modalTitle.textContent = '完成挑战!';
            modalTime.textContent = seconds;

            // 显示星级
            modalStars.style.display = 'flex';
            for (let i = 0; i < 3; i++) {
                const star = document.createElement('span');
                star.className = i < stars ? 'star active' : 'star';
                star.innerHTML = '★';
                modalStars.appendChild(star);
            }

            // 设置通关信息
            modalLevelMessage.classList.remove('hidden');

            if (currentLevel < levels.length) {
                // 不是最后一关的处理
                if (stars >= 3) {
                    // 获得3星，才算真正通关
                    modalTitle.textContent = '恭喜完成!';
                    modalLevelMessage.innerHTML = `<p>你已通关! <span id="modal-level-status" style="color:#1565C0;font-weight:bold;">解锁成功！准备挑战更高难度！</span></p>`;
                    modalNextBtn.style.display = 'block';
                    modalNextBtn.textContent = '下一关卡 →';

                    // 添加动画效果
                    setTimeout(() => {
                        modalNextBtn.classList.add('pulse-animation');
                    }, 500);
                } else if (stars === 2) {
                    // 获得2星 - 修改为未通关信息
                    modalLevelMessage.innerHTML = `<p>尚未通关! <span id="modal-level-status" style="color:#FFA500;font-weight:bold;">很接近了！再快一点就能获得3星通关并解锁下一关！</span></p>`;
                } else {
                    // 获得1星 - 保持未通关信息
                    modalLevelMessage.innerHTML = `<p>尚未通关! <span id="modal-level-status" style="color:#f44336;font-weight:bold;">需要获得3星才能通关，继续努力！</span></p>`;
                }
            } else {
                // 最后一关的处理
                if (stars >= 3) {
                    modalTitle.textContent = '恭喜完成!';
                    modalLevelMessage.innerHTML = `<p>恭喜！你已完成所有关卡！</p>`;
                } else {
                    modalLevelMessage.innerHTML = `<p>最后一关尚未达到通关标准，需要获得3星才算真正通关！</p>`;
                }
            }
        } else {
            // 游戏失败的处理

            // 隐藏星级显示
            modalStars.style.display = 'none';

            if (tooManyErrors) {
                // 错误次数过多导致失败
                modalTitle.textContent = '点击错误次数过多！';
                modalTime.textContent = seconds;
                modalLevelMessage.classList.remove('hidden');
                modalLevelMessage.innerHTML = `
                    <p style="color:#f44336;font-weight:bold;">
                        本关卡最多允许点错 ${maxWrongClicks} 次。请重新尝试！
                    </p>
                `;
            } else {
                // 时间用完导致失败
                modalTitle.textContent = '时间到！再试一次吧';
                modalTime.textContent = seconds;
                modalLevelMessage.classList.remove('hidden');
                modalLevelMessage.innerHTML = `
                    <p style="color:#ff9800;font-weight:bold;">
                        时间已用完，请再次尝试！
                    </p>
                `;
            }
        }

        // 显示蒙层
        modalOverlay.classList.add('active');

        // 隐藏时间限制条（如果有的话）
        timeLimitBarContainer.classList.add('hidden');
    }

    // 进入下一关
    function goToNextLevel() {
        const gameData = loadGameData();

        if (currentLevel < levels.length && gameData.levels[currentLevel + 1].unlocked) {
            currentLevel++;
            levelSelect.value = currentLevel;
            updateLevelDescription(currentLevel);

            // 隐藏蒙层
            modalOverlay.classList.remove('active');

            initGame();
        }
    }

    // 重新开始当前关卡
    function restartCurrentLevel() {
        // 隐藏蒙层
        modalOverlay.classList.remove('active');

        initGame();
    }

    // 设置所有事件监听器
    function setupEventListeners() {
        // 开始游戏按钮
        startBtn.addEventListener('click', initGame);

        // 显示关卡详情蒙层
        viewLevelDetailsBtn.addEventListener('click', () => {
            levelDetailOverlay.classList.add('active');
        });

        // 关闭关卡详情蒙层
        closeLevelDetailBtn.addEventListener('click', () => {
            levelDetailOverlay.classList.remove('active');
        });

        // 点击蒙层背景也可以关闭关卡详情
        levelDetailOverlay.addEventListener('click', function (e) {
            if (e.target === levelDetailOverlay) {
                levelDetailOverlay.classList.remove('active');
            }
        });

        // 蒙层按钮事件
        modalNextBtn.addEventListener('click', goToNextLevel);
        modalRestartBtn.addEventListener('click', restartCurrentLevel);

        // 点击蒙层背景不关闭蒙层，必须点击按钮
        modalOverlay.addEventListener('click', function (e) {
            if (e.target === modalOverlay) {
                // 不关闭，要求用户点击按钮
                // modalOverlay.classList.remove('active');
            }
        });

        // 关卡选择变化时更新描述
        levelSelect.addEventListener('change', () => {
            const selectedLevel = parseInt(levelSelect.value);
            updateLevelDescription(selectedLevel);
        });
    }

    // 初始化关卡数据和游戏
    function initialize() {
        initializeLevels();
        setupEventListeners();

        // 初始游戏状态提示
        gridContainer.innerHTML = '<div class="initial-message">点击"开始游戏"按钮开始</div>';
        document.querySelector('.initial-message').style.cssText =
            'grid-column: 1 / -1; text-align: center; padding: 20px; color: #666;';
    }

    // 执行初始化
    initialize();

    // 添加键盘事件监听器用于激活调试模式
    document.addEventListener('keydown', function (e) {
        // 只记录小写字母
        const key = e.key.toLowerCase();

        // 如果是字母键，则加入序列
        if (/^[a-z]$/.test(key)) {
            debugSequence.push(key);

            // 保持序列长度不超过激活码长度
            if (debugSequence.length > debugCode.length) {
                debugSequence.shift();
            }

            // 检查是否匹配激活码
            const isMatch = debugSequence.join('') === debugCode.join('');

            // 如果匹配并且调试模式未激活，则激活调试模式
            if (isMatch && !debugMode) {
                activateDebugMode();
            }
        }
    });

    // 激活调试模式
    function activateDebugMode() {
        debugMode = true;
        console.log('🔧 Debug mode activated');

        // 创建调试面板
        createDebugPanel();
    }

    // 关闭调试模式
    function deactivateDebugMode() {
        debugMode = false;

        // 移除调试面板
        if (debugPanel && debugPanel.parentNode) {
            debugPanel.parentNode.removeChild(debugPanel);
            debugPanel = null;
        }

        console.log('🔒 Debug mode deactivated');
    }

    // 创建调试面板
    function createDebugPanel() {
        // 如果已存在调试面板，则先移除
        if (debugPanel) {
            debugPanel.parentNode.removeChild(debugPanel);
        }

        // 创建面板容器
        debugPanel = document.createElement('div');
        debugPanel.className = 'debug-panel';
        debugPanel.style.cssText = `
            position: fixed;
            top: 10px;
            right: 10px;
            width: 300px;
            background-color: rgba(0, 0, 0, 0.8);
            color: #0f0;
            border: 1px solid #0f0;
            border-radius: 5px;
            padding: 10px;
            font-family: monospace;
            font-size: 14px;
            z-index: 9999;
            box-shadow: 0 0 10px rgba(0, 255, 0, 0.5);
        `;

        // 添加标题
        const title = document.createElement('div');
        title.textContent = '🛠️ DEBUG MODE';
        title.style.cssText = `
            text-align: center;
            font-weight: bold;
            font-size: 16px;
            margin-bottom: 10px;
            border-bottom: 1px solid #0f0;
            padding-bottom: 5px;
        `;
        debugPanel.appendChild(title);

        // 添加调试工具按钮
        const tools = [
            { label: '🔓 解锁所有关卡', action: unlockAllLevels },
            { label: '⭐ 获得所有关卡3星', action: awardAllLevelsThreeStars },
            { label: '✅ 立即完成当前关卡', action: completeCurrentLevel },
            { label: '🔄 重置所有游戏数据', action: resetAllGameData },
            { label: '⏱️ 设置时间为1秒', action: setTimeTo1Second },
            { label: '🔊 开关音效', action: toggleSound },
            { label: '❌ 关闭调试模式', action: deactivateDebugMode },
        ];

        tools.forEach(tool => {
            const button = document.createElement('button');
            button.textContent = tool.label;
            button.style.cssText = `
                display: block;
                width: 100%;
                background-color: #222;
                color: #0f0;
                border: 1px solid #0f0;
                border-radius: 3px;
                padding: 5px;
                margin: 5px 0;
                cursor: pointer;
                font-family: monospace;
                text-align: left;
            `;
            button.addEventListener('mouseover', function () {
                this.style.backgroundColor = '#333';
            });
            button.addEventListener('mouseout', function () {
                this.style.backgroundColor = '#222';
            });
            button.addEventListener('click', tool.action);
            debugPanel.appendChild(button);
        });

        // 添加当前游戏状态信息
        const statusInfo = document.createElement('div');
        statusInfo.style.cssText = `
            margin-top: 10px;
            font-size: 12px;
            border-top: 1px solid #0f0;
            padding-top: 5px;
        `;

        // 更新状态信息的函数
        function updateStatusInfo() {
            const gameData = loadGameData();
            const currentLevelData = gameData.levels[currentLevel];

            statusInfo.innerHTML = `
                当前关卡: ${currentLevel}<br>
                游戏状态: ${gameActive ? '进行中' : '未开始'}<br>
                计时: ${seconds}秒<br>
                错误点击: ${wrongClicks}/${maxWrongClicks}<br>
                当前星级: ${currentLevelData ? currentLevelData.stars : 0}星<br>
                最佳时间: ${currentLevelData && currentLevelData.bestTime ? currentLevelData.bestTime : '无'}秒
            `;
        }

        // 初次更新状态
        updateStatusInfo();
        debugPanel.appendChild(statusInfo);

        // 每秒更新状态信息
        const statusUpdateTimer = setInterval(updateStatusInfo, 1000);

        // 当调试面板被移除时清除状态更新定时器
        debugPanel.addEventListener('remove', function () {
            clearInterval(statusUpdateTimer);
        });

        // 添加到页面
        document.body.appendChild(debugPanel);
    }

    // 解锁所有关卡
    function unlockAllLevels() {
        const gameData = loadGameData();

        levels.forEach(level => {
            gameData.levels[level.id].unlocked = true;
        });

        saveGameData(gameData);
        updateLevelSelectWithStars();

        alert('已解锁所有关卡');
    }

    // 给所有关卡设置3星
    function awardAllLevelsThreeStars() {
        const gameData = loadGameData();

        levels.forEach(level => {
            gameData.levels[level.id].stars = 3;
            // 设置一个虚拟的最佳时间（刚好能获得3星的时间）
            gameData.levels[level.id].bestTime = level.starTimes[2];
        });

        saveGameData(gameData);
        updateLevelSelectWithStars();

        alert('已为所有关卡设置3星评级');
    }

    // 立即完成当前关卡
    function completeCurrentLevel() {
        if (!gameActive) {
            alert('请先开始游戏');
            return;
        }

        // 设置当前数字为最后一个数字
        currentNumber = maxNumber;

        // 立即完成游戏
        gameComplete(true);

        alert('已立即完成当前关卡');
    }

    // 重置所有游戏数据
    function resetAllGameData() {
        if (confirm('确定要重置所有游戏数据吗？此操作不可恢复！')) {
            localStorage.removeItem(STORAGE_KEY);
            alert('游戏数据已重置，页面将刷新');
            location.reload();
        }
    }

    // 设置时间为1秒（确保获得3星）
    function setTimeTo1Second() {
        if (!gameActive) {
            alert('请先开始游戏');
            return;
        }

        seconds = 1;
        timerElement.textContent = seconds;
    }

    // 开关音效
    let soundEnabled = true;
    function toggleSound() {
        soundEnabled = !soundEnabled;

        // 更新所有音频对象的音量
        [correctAudio, wrongAudio, successAudio, failureAudio].forEach(audio => {
            audio.volume = soundEnabled ? 0.5 : 0;
        });

        alert(soundEnabled ? '音效已开启' : '音效已关闭');
    }

    // 关闭关卡详情蒙层
    function closeLevelDetailModal() {
        levelDetailOverlay.classList.remove('active');
    }

    // 当游戏状态切换时也可能需要关闭关卡详情蒙层
    startBtn.addEventListener('click', function () {
        if (levelDetailOverlay.classList.contains('active')) {
            closeLevelDetailModal();
        }
        initGame();
    });
});
